package com.study.methodcontrucet;


import org.junit.Test;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @author yangyb
 * <p>
 * 方法引用的使用：
 * 1、使用情景：当要传递给labda体的操作，已经有实现的方法了，可以使用方法引用！！
 * <p>
 * 2、方法的引用本质就是lambda表达式，而lambda表达式的本质就是函数式接口的实例。所以
 * 方法的引用，也是函数式接口的实例
 * <p>
 * 3、使用格式：类（或对象）：：方法名
 * 情况：
 * - 对象：：实例方法名（非静态方法）
 * - 类：：静态方法名
 * - 类：：实例方法名（非静态方法）
 * 4、使用要求：
 * - 要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法参数列表和返回值类型保持一致！
 */
public class MethodRefTest {
    /**
     * 情况一：对象：：实例方法
     * Consumer中的void accept(T t)
     * PrintStream 中的void println(T t)
     */
    @Test
    public void test1() {
        Consumer<String> consumer = str -> System.out.println(str);
        consumer.accept("西安");

        System.out.println("**********************");
        PrintStream printStream = System.out;
        Consumer<String> consumer1 = printStream::println;
        consumer1.accept("beijing");


    }

    @Test
    public void test2() {
        /**
         * Employee 中 String getName()方法
         * Supplier 中T get()
         */
        Employee employee = new Employee(1003, "EDG", 18, 100000000.00);
        Supplier<String> supplier = () -> employee.getName();
        System.out.println(supplier.get());

        System.out.println("*******************");
        Supplier<String> supplier1 = employee::getName;
        System.out.println(supplier1.get());

    }

    /**
     * 情况二：类：：静态方法
     * comparator 中的int compare(T t1, T t2)
     * Integer 中的int compare(T t1,T t2)
     */
    @Test
    public void test3() {
        Comparator<Integer> comparator = (t1, t2) -> Integer.compare(t1, t2);
        System.out.println(comparator.compare(23, 89));

        System.out.println("*********");

        Comparator<Integer> comparator1 = Integer::compare;
        System.out.println(comparator1.compare(89, 90));

    }

    /**
     * 情况二：类：：静态方法
     * Function 中的R apply(T t1)
     * Integer 中的Long round(Double t)
     */
    @Test
    public void test4() {
        Function<Double, Long> function = new Function<Double, Long>() {

            @Override
            public Long apply(Double aDouble) {
                return Math.round(aDouble);
            }
        };
        System.out.println("*****************");
        Function<Double, Long> function1 = d -> Math.round(d);
        System.out.println(function1.apply(34.98));
        System.out.println("*****************");
        Function<Double, Long> function2 = Math::round;
        System.out.println(function1.apply(34.45));

    }

    /**
     * 情况三：类：：实例方法(非静态方法)
     * comparator 中的int compare(T t1, T t2)
     * String 中的int t1.compareTo(t2)
     */
    @Test
    public void test5() {
        Comparator<String> comparator = (s1, s2) -> s1.compareTo(s2);
        System.out.println(comparator.compare("aed", "ert"));
        System.out.println("*****************");
        Comparator<String> comparator2 = String::compareTo;
        System.out.println(comparator2.compare("wer", "wet"));

    }

    /**
     * BiPredicate中的boolean test (T t1, T t2);
     * String 中的boolean t1.equals(t2)
     */
    @Test
    public void test6() {
        BiPredicate<String, String> biPredicate = (s1, s2) -> s1.equals(s2);
        System.out.println(biPredicate.test("wer", "wertyu"));
        System.out.println("*****************");
        BiPredicate<String, String> biPredicate2 = String::equals;
        System.out.println(biPredicate2.test("wery", "wet"));

    }

    /**
     * 情况二：类：：静态方法
     * comparator 中的int compare(T t1, T t2)
     * Integer 中的int compare(T t1,T t2)
     */
    @Test
    public void test7() {

    }


    /**
     * 情况二：类：：静态方法
     * comparator 中的int compare(T t1, T t2)
     * Integer 中的int compare(T t1,T t2)
     */
    @Test
    public void test8() {

    }

}
